import axios from 'axios'

// AI API配置
const AI_CONFIG = {
  baseURL: 'https://ai.gitee.com/v1',
  apiKey: process.env.VUE_APP_AI_API_KEY || '', // todo 从环境变量获取API密钥
  model: 'DeepSeek-V3',
  timeout: 30000
}

// 创建AI API客户端
const aiClient = axios.create({
  baseURL: AI_CONFIG.baseURL,
  timeout: AI_CONFIG.timeout,
  headers: {
    'Content-Type': 'application/json',
    'Authorization': `Bearer ${AI_CONFIG.apiKey}`
  }
})

// 创建后端API客户端（用于快捷操作管理）
const backendClient = axios.create({
  baseURL: 'http://localhost:8081/api',
  timeout: 10000,
  headers: {
    'Content-Type': 'application/json'
  }
})

// 后端API响应拦截器
backendClient.interceptors.response.use(
  response => {
    // 如果后端返回的是标准格式 { success: true, data: ... }
    if (response.data && typeof response.data === 'object' && 'success' in response.data) {
      if (response.data.success) {
        return response.data.data
      } else {
        throw new Error(response.data.message || '请求失败')
      }
    }
    return response.data
  },
  error => {
    console.error('后端API错误:', error)
    if (error.response) {
      const message = error.response.data?.message || `请求失败: ${error.response.status}`
      throw new Error(message)
    } else if (error.request) {
      throw new Error('网络连接失败，请检查后端服务是否启动')
    } else {
      throw new Error(error.message || '未知错误')
    }
  }
)

// AI API类
class AIAPI {
  /**
   * 发送聊天请求（流式响应）
   * @param {Array} messages - 消息数组
   * @param {Object} options - 配置选项
   * @param {Function} onMessage - 消息回调函数
   * @param {Function} onError - 错误回调函数
   * @param {Function} onComplete - 完成回调函数
   */
  async chatStream(messages, options = {}, onMessage, onError, onComplete) {
    try {
      if (!AI_CONFIG.apiKey) {
        throw new Error('AI API密钥未配置，请在环境变量中设置VUE_APP_AI_API_KEY')
      }

      const requestData = {
        model: options.model || AI_CONFIG.model,
        messages: messages,
        stream: true,
        max_tokens: options.maxTokens || 1024,
        temperature: options.temperature || 0.7,
        top_p: options.topP || 0.9,
        frequency_penalty: options.frequencyPenalty || 0.1
      }

      const response = await fetch(`${AI_CONFIG.baseURL}/chat/completions`, {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json',
          'Authorization': `Bearer ${AI_CONFIG.apiKey}`
        },
        body: JSON.stringify(requestData)
      })

      if (!response.ok) {
        const errorData = await response.json().catch(() => ({}))
        throw new Error(errorData.error?.message || `HTTP ${response.status}: ${response.statusText}`)
      }

      const reader = response.body.getReader()
      const decoder = new TextDecoder()
      let buffer = ''

      // eslint-disable-next-line no-constant-condition
      while (true) {
        const { done, value } = await reader.read()
        if (done) break

        buffer += decoder.decode(value, { stream: true })
        const lines = buffer.split('\n')
        buffer = lines.pop() || ''

        for (const line of lines) {
          const trimmedLine = line.trim()
          if (trimmedLine.startsWith('data: ')) {
            const data = trimmedLine.slice(6)
            if (data === '[DONE]') {
              onComplete && onComplete()
              return
            }

            try {
              const parsed = JSON.parse(data)
              const content = parsed.choices?.[0]?.delta?.content
              if (content) {
                onMessage && onMessage(content)
              }
            } catch (e) {
              console.warn('解析SSE数据失败:', e, data)
            }
          }
        }
      }

      onComplete && onComplete()
    } catch (error) {
      console.error('AI聊天流式请求失败:', error)
      onError && onError(error)
    }
  }

  /**
   * 发送普通聊天请求（非流式）
   * @param {Array} messages - 消息数组
   * @param {Object} options - 配置选项
   */
  async chat(messages, options = {}) {
    try {
      if (!AI_CONFIG.apiKey) {
        throw new Error('AI API密钥未配置，请在环境变量中设置VUE_APP_AI_API_KEY')
      }

      const requestData = {
        model: options.model || AI_CONFIG.model,
        messages: messages,
        stream: false,
        max_tokens: options.maxTokens || 1024,
        temperature: options.temperature || 0.7,
        top_p: options.topP || 0.9,
        frequency_penalty: options.frequencyPenalty || 0.1
      }

      const response = await aiClient.post('/chat/completions', requestData)
      return response.data.choices[0].message.content
    } catch (error) {
      console.error('AI聊天请求失败:', error)
      if (error.response?.data?.error) {
        throw new Error(error.response.data.error.message || 'AI请求失败')
      }
      throw error
    }
  }

  /**
   * 构建带文章上下文的消息
   * @param {string} userMessage - 用户消息
   * @param {Object} article - 文章对象
   * @param {string} systemPrompt - 系统提示词
   */
  buildMessagesWithContext(userMessage, article, systemPrompt) {
    const messages = []
    
    // 系统消息
    const defaultSystemPrompt = `你是一个专业的写作助手，专门帮助用户改进和优化文章内容。你具备以下能力：
1. 文章润色和语言优化
2. 结构调整和逻辑梳理
3. 标题生成和关键词提取
4. 内容扩展和补充建议
5. 语法检查和错误纠正

请根据用户的需求，结合提供的文章内容，给出专业、实用的建议和修改方案。`
    
    messages.push({
      role: 'system',
      content: systemPrompt || defaultSystemPrompt
    })

    // 如果有文章内容，添加上下文
    if (article && (article.title || article.content)) {
      let contextContent = '当前文章信息：\n'
      if (article.title) {
        contextContent += `标题：${article.title}\n`
      }
      if (article.content) {
        contextContent += `内容：\n${article.content}\n`
      }
      
      messages.push({
        role: 'user',
        content: contextContent
      })
      
      messages.push({
        role: 'assistant',
        content: '我已经了解了您的文章内容，请告诉我您需要什么帮助？'
      })
    }

    // 用户消息
    messages.push({
      role: 'user',
      content: userMessage
    })

    return messages
  }
}

// 快捷操作API类
class ShortcutAPI {
  /**
   * 获取所有快捷操作
   */
  async getAll() {
    try {
      return await backendClient.get('/ai-shortcuts')
    } catch (error) {
      console.error('获取快捷操作失败:', error)
      throw error
    }
  }

  /**
   * 创建快捷操作
   * @param {Object} shortcutData - 快捷操作数据
   */
  async create(shortcutData) {
    try {
      return await backendClient.post('/ai-shortcuts', shortcutData)
    } catch (error) {
      console.error('创建快捷操作失败:', error)
      throw error
    }
  }

  /**
   * 更新快捷操作
   * @param {number} id - 快捷操作ID
   * @param {Object} updateData - 更新数据
   */
  async update(id, updateData) {
    try {
      return await backendClient.put(`/ai-shortcuts/${id}`, updateData)
    } catch (error) {
      console.error('更新快捷操作失败:', error)
      throw error
    }
  }

  /**
   * 删除快捷操作
   * @param {number} id - 快捷操作ID
   */
  async delete(id) {
    try {
      await backendClient.delete(`/ai-shortcuts/${id}`)
      return true
    } catch (error) {
      console.error('删除快捷操作失败:', error)
      throw error
    }
  }

  /**
   * 批量删除快捷操作
   * @param {Array} ids - 快捷操作ID数组
   */
  async batchDelete(ids) {
    try {
      await backendClient.delete('/ai-shortcuts/batch', {
        data: { ids }
      })
      return true
    } catch (error) {
      console.error('批量删除快捷操作失败:', error)
      throw error
    }
  }
}

// 导出API实例
export const aiApi = new AIAPI()
export const shortcutApi = new ShortcutAPI()

// 默认导出
export default {
  ai: aiApi,
  shortcut: shortcutApi
}